package streamDemo;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

class User {
    private final int age;
    private final int id;
    private final String name;

    public User(int age, int id, String name) {
        this.age = age;
        this.id = id;
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }

    public int getId() {
        return id;
    }
}

/**
 * 链式编程 流式计算
 * <p>
 * 按照给出的数据，找出同时满足以下条件的用户：
 * 偶数ID，年龄>24，用户名转为大写 且 对字母排序
 * 最后输出前2个
 * <p>
 * List 和 stream 的互换
 */
public class StreamDemo {

    public static void main(String[] args) {
        User user1 = new User(33, 204, "Ben");
        User user2 = new User(30, 202, "Ken");
        User user3 = new User(23, 25, "Len");
        User user4 = new User(25, 210, "Ten");
        User user5 = new User(41, 230, "Uen");
        User user6 = new User(4, 221, "Pen");
        List<User> list = Arrays.asList(user1, user2, user3, user4, user5, user6);

        // map-reduce 思想
        list.stream()
                .filter(user -> user.getId() % 2 == 0 && user.getAge() > 24)
                .map(user -> user.getName().toUpperCase())
                .sorted(Comparator.reverseOrder())
                .limit(2)
                .forEach(System.out::println);
        System.out.println();
    }


    private void test4Interface() {
        //        Function<String, Integer> function = new Function<String, Integer>() {
//            @Override
//            public Integer apply(String s) {
//                return 1024;
//            }
//        };   接口一new，本质上就是匿名内部类实现这个接口，只要是函数式接口，就可以简化为lambda表达式

        //       输入参数  返回参数
        Function<String, Integer> function = s -> {
            return s.length() + 10;
        };
        function.apply("hello");

//        Predicate<String> predicate = new Predicate<String>() {
//            @Override
//            public boolean test(String s) {
//                return s.length() > 5;
//            }
//        }
        Predicate<String> predicate = String::isEmpty;
        predicate.test("wowowirweqho");

        Consumer<String> consumer = s -> {
            System.out.println("hello " + s);
        };
        consumer.accept("Beney");

        Supplier<String> supplier = () -> "cake";
        System.out.println(supplier.get());
    }
}

interface MyInterface<R, T> {
    public void comsumer(T para);       // 消费型接口，特定的输入类型，无返回。
    public boolean predicate(T para);   // 判定型接口，特定输入类型，boolean类型返回。
    public R function(T para);          // 函数型接口，操作对象，特定输入、返回类型。
    public R supply();                  // 供给型接口，无输入，有返回。
}


